package duotai;
class one{
    public int a = 10;

    public one(int a) {
        this.a = a;
    }
    public void show_a() {
        System.out.println("a = "+a);
    }

    //动态绑定,父类与子类的方法名相同，返回值相同，参数相同
    public one show() {
        return null;
    }
}

/**
 * two 继承了one这个类
 * one就是two父类
 *
 */
class two extends one{
    public int b = 0;

    public two(int a,int b){
        super(a);
        this.b = b;
    }
    @Override
    public two show() {
        System.out.println("TWO b = " + b);
        return null;
    }

    public void show_one() {
        show_a();
    }
}

class threeText extends one {

    int b;
    public threeText(int a, int b) {
        super(a);
        this.b = b;
    }

    /**
     * 动态绑定
     * 子类的方法和父类的相同，在发生向上转型的时候子类会重写父类的方法
     * 这时调用父类被重写的方法其实就是在调用的是子类的方法
     * 在发生向上转型的时候子类的方法必须和父类的返回值 方法名字 传参相同
     * 访问权限子类的要大于父类的
     */
    public one show() {
        System.out.println("b = " + b);
        return null;
    }
}

public class xianshanzhuanxin {
    public static void main(String[] args) {
        //向上转型 你把创捷个子类对象，但是你给赋给了父类
        one a = new two(1, 2);
        a.show();

        fun(new two(1, 2));
        fun(new threeText(1, 2));

    }
    public static void show(one theone) {
        theone.show_a();
    }

    public static one show1(int a) {
        return new one(a);
    }

    public static void fun(one name) {
        name.show();
    }

    public static void main11(String[] args) {
        //多态
        two n1 = new two(3, 4);
        three n2 = new three(2, 6);
        threeText n3 = new threeText(3, 7);
        //只是调用了name.show_b这个方法，但是因为传入的参数不同、
        // 实际产生的结果不同
        fun(n1);
        fun(n2);
        fun(n3);
        //直接赋值
//        one h = new two(3,4);//大范围概括小范围
//        h.show_a();
//        //参数调用 父类可以调用自己有的成员
//        show(h);
//        //方法返回
//        show1(2).show_a();
//        h.show_b();//调用了父类的方法，实现的却是子类的方法
        //发生了重写，子类的方法重写了父类的方法，这种情况叫做动态绑定


    }
}
